import pytest  # used for our unit tests
from matplotlib._mathtext import Error
from pyparsing import ParseFatalException

# unit tests

# 1. Basic Test Cases


def test_error_raises_with_basic_message():
    """Test that Error raises ParseFatalException with the correct message on basic input."""
    codeflash_output = Error("basic error")
    parser = codeflash_output  # 17.2μs -> 14.0μs (22.8% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("anything")


def test_error_with_empty_string_message():
    """Test that Error raises with an empty string message."""
    codeflash_output = Error("")
    parser = codeflash_output  # 17.1μs -> 13.7μs (24.3% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("data")


def test_error_with_special_characters_in_message():
    """Test that Error raises with a message containing special characters."""
    special_msg = "err!@#\n\t"
    codeflash_output = Error(special_msg)
    parser = codeflash_output  # 16.6μs -> 13.3μs (25.0% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_with_unicode_message():
    """Test that Error raises with a unicode message."""
    unicode_msg = "Ошибка 🚫"
    codeflash_output = Error(unicode_msg)
    parser = codeflash_output  # 16.6μs -> 13.6μs (22.3% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("тест")


# 2. Edge Test Cases


def test_error_with_empty_input_string():
    """Test Error with an empty input string."""
    codeflash_output = Error("Empty input error")
    parser = codeflash_output  # 16.8μs -> 13.6μs (23.7% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("")


def test_error_with_long_message():
    """Test Error with a very long message string."""
    long_msg = "X" * 1000
    codeflash_output = Error(long_msg)
    parser = codeflash_output  # 17.1μs -> 13.9μs (23.2% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("longinput")


def test_error_with_non_ascii_input_string():
    """Test Error with non-ASCII input string."""
    codeflash_output = Error("Non-ASCII input error")
    parser = codeflash_output  # 16.8μs -> 13.7μs (22.7% faster)
    input_str = "测试数据"
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString(input_str)


def test_error_with_whitespace_input_string():
    """Test Error with input string containing only whitespace."""
    codeflash_output = Error("Whitespace error")
    parser = codeflash_output  # 16.6μs -> 13.7μs (21.9% faster)
    input_str = " \t\n "
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString(input_str)


def test_error_with_location_parameter():
    """Test that the location parameter in the exception is always 0 (since Empty always matches at start)."""
    codeflash_output = Error("Location test")
    parser = codeflash_output  # 16.5μs -> 13.4μs (23.2% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("abcdef")


def test_error_with_multiple_calls():
    """Test that multiple calls to the same Error parser each raise the correct error."""
    codeflash_output = Error("Repeated error")
    parser = codeflash_output  # 16.7μs -> 13.5μs (24.2% faster)
    for i in range(3):
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(f"input{i}")


# 3. Large Scale Test Cases


def test_error_with_large_input_string():
    """Test Error with a very large input string."""
    codeflash_output = Error("Large input error")
    parser = codeflash_output  # 16.3μs -> 13.5μs (20.3% faster)
    large_input = "A" * 1000
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString(large_input)


def test_error_with_many_different_messages():
    """Test Error with many different messages to ensure no cross-contamination."""
    for i in range(100):
        msg = f"Error {i}"
        codeflash_output = Error(msg)
        parser = codeflash_output  # 482μs -> 315μs (53.0% faster)
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(f"input_{i}")


def test_error_parser_type_and_repr():
    """Test that the returned object is a ParserElement and its repr contains the message."""
    msg = "repr test"
    codeflash_output = Error(msg)
    parser = codeflash_output  # 16.8μs -> 13.4μs (25.4% faster)


def test_error_parser_does_not_consume_input():
    """Test that Error parser does not consume any input (Empty)."""
    codeflash_output = Error("Does not consume")
    parser = codeflash_output  # 16.8μs -> 13.6μs (23.3% faster)
    with pytest.raises(ParseFatalException):
        result = parser.parseString("abcde", parseAll=False)
    # The input should remain unchanged after failure


def test_error_with_various_input_types():
    """Test Error with various types of input strings, including numbers and symbols."""
    codeflash_output = Error("Various input types")
    parser = codeflash_output  # 16.5μs -> 13.6μs (21.6% faster)
    inputs = ["123456", "!@#$%^&*()", "mixed123!@#", "long" * 250]
    for inp in inputs:
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(inp)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from matplotlib._mathtext import Error
from pyparsing import ParseFatalException

# unit tests

# -------------------- BASIC TEST CASES --------------------


def test_error_raises_with_simple_message():
    # Test that Error raises the correct exception with a simple message
    codeflash_output = Error("Test error")
    parser = codeflash_output  # 16.8μs -> 13.5μs (24.7% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("anything")


def test_error_raises_with_empty_message():
    # Test that Error raises with an empty message
    codeflash_output = Error("")
    parser = codeflash_output  # 16.8μs -> 13.3μs (26.0% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_special_characters_in_message():
    # Test that Error raises with a message containing special characters
    special_msg = "Error: something went wrong! @#%$"
    codeflash_output = Error(special_msg)
    parser = codeflash_output  # 16.7μs -> 13.4μs (24.7% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_unicode_message():
    # Test that Error raises with a unicode message
    unicode_msg = "Ошибка: неверный ввод 🚫"
    codeflash_output = Error(unicode_msg)
    parser = codeflash_output  # 16.7μs -> 13.2μs (26.9% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


# -------------------- EDGE TEST CASES --------------------


def test_error_raises_with_long_message():
    # Test with a very long error message
    long_msg = "X" * 1000
    codeflash_output = Error(long_msg)
    parser = codeflash_output  # 16.3μs -> 13.3μs (22.0% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_empty_input():
    # Test that Error raises even when input is empty
    codeflash_output = Error("Empty input error")
    parser = codeflash_output  # 16.8μs -> 13.2μs (27.2% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("")


def test_error_raises_with_whitespace_input():
    # Test with input that is only whitespace
    codeflash_output = Error("Whitespace error")
    parser = codeflash_output  # 16.9μs -> 13.0μs (30.3% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("   \t\n ")


def test_error_raises_with_non_string_message():
    # Test with a non-string message (should convert to string or raise)
    codeflash_output = Error(12345)
    parser = codeflash_output  # 16.8μs -> 13.5μs (24.8% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_none_message():
    # Test with None as message (should convert to string 'None')
    codeflash_output = Error(None)
    parser = codeflash_output  # 17.0μs -> 13.4μs (26.7% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_loc_argument():
    # Test that location argument is correctly passed to exception
    codeflash_output = Error("Location test")
    parser = codeflash_output  # 16.5μs -> 13.2μs (25.6% faster)
    input_str = "abc"
    try:
        parser.parseString(input_str)
    except ParseFatalException as e:
        pass
    else:
        pass


# -------------------- LARGE SCALE TEST CASES --------------------


def test_error_raises_with_large_input():
    # Test that Error raises with a large input string
    codeflash_output = Error("Large input error")
    parser = codeflash_output  # 16.5μs -> 13.2μs (25.0% faster)
    large_input = "a" * 1000
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString(large_input)


def test_error_raises_multiple_times_in_loop():
    # Test that Error can be used repeatedly without side effects
    codeflash_output = Error("Repeated error")
    parser = codeflash_output  # 16.5μs -> 12.7μs (29.9% faster)
    for i in range(10):  # keep below 1000 for performance
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(str(i))


def test_error_parser_element_type():
    # Test that Error returns a ParserElement instance
    codeflash_output = Error("Type test")
    parser = codeflash_output  # 16.6μs -> 13.4μs (24.3% faster)


def test_error_does_not_consume_input():
    # Error should not consume any input, since it uses Empty()
    codeflash_output = Error("No consume")
    parser = codeflash_output  # 17.8μs -> 14.3μs (24.6% faster)
    with pytest.raises(ParseFatalException):
        parser.parseString("someinput")
    # If we use Empty() alone, it would succeed and not consume input


def test_error_always_raises():
    # Error should always raise, regardless of input
    codeflash_output = Error("Always error")
    parser = codeflash_output  # 16.8μs -> 13.3μs (25.7% faster)
    for test_input in ["", "abc", "123", "!", "long" * 100]:
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(test_input)


def test_error_with_parse_action_signature():
    # Ensure parse action signature matches pyparsing requirements
    codeflash_output = Error("Signature test")
    parser = codeflash_output  # 16.9μs -> 13.3μs (26.5% faster)
    # Should accept (str, int, ParseResults)
    with pytest.raises(ParseFatalException):
        parser.parseString("signature")


# -------------------- NEGATIVE TESTS --------------------


def test_error_does_not_raise_other_exceptions():
    # Ensure Error only raises ParseFatalException, not other exceptions
    codeflash_output = Error("Fatal only")
    parser = codeflash_output  # 16.8μs -> 13.2μs (27.1% faster)
    try:
        parser.parseString("input")
    except Exception as e:
        pass


def test_error_message_mutation():
    # Mutation: If Error does NOT raise, this test should fail
    codeflash_output = Error("Mutation test")
    parser = codeflash_output  # 16.6μs -> 13.1μs (26.5% faster)
    try:
        result = parser.parseString("input")
    except ParseFatalException as e:
        pass


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.